import java.util.Scanner;

/**
 * Created With IntelliJ IDEA
 * Description:PTA：三元组顺序表表示的稀疏矩阵加法
 * User: DELL
 * Data: 2022-11-22
 * Time: 23:00
 */
//输入格式:
//        输入第1行为两个同型矩阵的行数m、列数n，矩阵A的非零元素个数t1，矩阵B的非零元素个数t2。
//        按行优先顺序依次输入矩阵A三元组数据，共t1行，每行3个数，分别表示非零元素的行标、列标和值。
//        按行优先顺序依次输入矩阵B三元组数据，共t2行，每行3个数，分别表示非零元素的行标、列标和值。
//输出格式:
//        输出第1行为相加后矩阵行数m、列数n及非零元素个数t。
//        输出t行相加后的三元组顺序表结果，每行输出非零元素的行标、列标和值，每行数据之间用空格分隔。
//输入样例：
//            4 4 3 4
//            0 1 -5
//            1 3 1
//            2 2 1
//            0 1 3
//            1 3 -1
//            3 0 5
//            3 3 7
//输出样例：
//            4 4 4
//            0 1 -2
//            2 2 1
//            3 0 5
//            3 3 7

    //解题的时候要特别注意，当两个非零元素相加后为0的时候，就需要舍弃这个元素
public class Main {
    public static void fun (int[] src,int[] dst) {
        dst[0] = src[0];
        dst[1] = src[1];
        dst[2] = src[2];
    }
    public static void main(String[] args) {
        int m = 0;
        int n = 0;
        int t1 = 0;
        int t2 = 0;
        Scanner scanner = new Scanner(System.in);
        m = scanner.nextInt();
        n = scanner.nextInt();
        t1 = scanner.nextInt();
        t2 = scanner.nextInt();
        int[][] src1 = new int[t1][3];
        int[][] src2 = new int[t2][3];
        for (int i = 0; i < t1; i++) {
            src1[i][0] = scanner.nextInt();
            src1[i][1] = scanner.nextInt();
            src1[i][2] = scanner.nextInt();
        }
        for (int i = 0; i < t2; i++) {
            src2[i][0] = scanner.nextInt();
            src2[i][1] = scanner.nextInt();
            src2[i][2] = scanner.nextInt();
        }
        int max = t1 + t2;  //两个矩阵相加后，非零元素最多为max
        int[][] dst = new int[max][3];
        int i = 0;
        int j = 0;
        int k = 0;
        while (i < t1 && j < t2) {
            int tmp1 = src1[i][0] - src2[i][0];
            if (tmp1 < 0) {
                fun(src1[i],dst[k]);
                k++;
                i++;
            } else if (tmp1 > 0) {
                fun(src2[j],dst[k]);
                k++;
                j++;
            } else {//行号相同时
                int tmp2 = src1[i][1] - src2[j][1];
                if (tmp2 < 0) {
                    fun(src1[i],dst[k]);
                    k++;
                    i++;
                } else if (tmp2 > 0) {
                    fun(src2[j], dst[k]);
                    k++;
                    j++;
                } else {//列号相同时
                    if (src1[i][2] + src2[j][2] == 0) {
                        i++;
                        j++;
                    } else {//两个数相加不为零时
                        dst[k][0] = src1[i][0];
                        dst[k][1] = src1[i][1];
                        dst[k][2] = src1[i][2] + src2[j][2];
                        k++;
                        i++;
                        j++;
                    }
                }
            }
        }
        //将剩余的非零元素直接放入dst中
        if (i == t1) {
            while (j < t2) {
                fun(src2[j], dst[k]);
                k++;
                j++;
            }
        } else {
            while (i < t1) {
                fun(src1[i], dst[k]);
                k++;
                i++;
            }
        }
        //输出矩阵
        System.out.println(m + " " + n + " " + k);
        for (i = 0; i < k; i++) {
            System.out.println(dst[i][0] + " " + dst[i][1] + " " + dst[i][2]);
        }
    }
}
